package com.grape.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.extension.service.IService;
import com.grape.domain.BaseDomain;
import com.grape.result.R;
import com.grape.utils.StringUtils;
import com.grape.wrapper.BaseWrapper;
import org.apache.logging.log4j.util.Strings;

import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;


/**
 * 公共控制器
 * @author  putao
 * @email   2628279194@qq.com
 */
public class BaseController<T extends BaseDomain> {

    /**
     * 修改删除标记
     * @param collection    集合数据
     * @param result        结果值
     * @return              通用接口结果
     */
    protected R<?> modifyDelFlag(Collection<T> collection, String result) {
        for (T s : collection) {
            if (result.equals(s.getDelFlag())) {
                return deleteErrorByStatus(null, null);
            }
            s.setDelFlag(result);
        }
        return null;
    }

    /**
     * 根据ids删除对应数据，当sonService和columnName不为空时删除对应数据
     * @param id            多个id以,分隔
     * @param service       删除方法的service对象
     * @param sonService    用于删除子表的service对象
     * @param columnName    表字段名 下划线形式
     * @return              通用接口结果
     */
    protected R<?> delete(String id, IService<T> service, IService sonService, String columnName) {
        if (!Strings.isNotBlank(id)) {
            return argumentError(id, null);
        }
        List<String> idList = StringUtils.convertList(id);
        if (CollectionUtil.isNotEmpty(idList)) {
            if (ObjectUtil.isNotEmpty(service)) {
                R<?> r = listAndDel(idList, service, null);
                if (ObjectUtil.isNotEmpty(r)) return r;
            }
            if (ObjectUtil.isNotEmpty(sonService) && StringUtils.isNotBlank(columnName)) {
                R<?> r = listAndDel(idList, sonService, columnName);
                if (ObjectUtil.isNotEmpty(r)) return r;
            }
        }
        return deleteSuccess(id, null);
    }

    /**
     * 查出数据并修改删除标记
     * @param idList        ID集合
     * @param service       service对象
     * @param columnName    字段名，ID集合对应的字段名
     * @return              通用接口结果
     */
    protected R<?> listAndDel(List<String> idList, IService<T> service, String columnName) {
        Collection<T> collection;
        if (StringUtils.isNotBlank(columnName)) {
            collection = service.list(new BaseWrapper<T>().init().in(columnName, idList));
        } else {
            collection = service.listByIds(idList);
        }
        if (CollectionUtil.isNotEmpty(collection)) {
            for (T t : collection) {
                if (BaseDomain.DEL_FLAG_DELETE.equals(t.getDelFlag())) {
                    return deleteErrorByStatus(null, null);
                }
                t.updateInit();
                t.setDelFlag(BaseDomain.DEL_FLAG_DELETE);
            }
            service.updateBatchById(collection);
        }
        return null;
    }

    /**
     * 批量删除操作
     * @param id            多个id使用,拼接
     * @param service       执行删除的service实现类
     * @param consumer      消费性接口，如果需要使用id查出的数据进行操作时可以传入该接口实现类，重新accept方法，参数是根据id查出的数据集合的每个元素
     * @return JsonResult   通用接口结果
     */
    protected R<?> delete(String id, IService<T> service, Consumer<T> consumer) {
        if (!Strings.isNotBlank(id)) {
            return argumentError(id, null);
        }
        List<String> idList = StringUtils.convertList(id);
        boolean result = false;
        if (CollectionUtil.isNotEmpty(idList)) {
            Collection<T> list = service.listByIds(idList);
            if (CollectionUtil.isNotEmpty(list)) {
                for (T t : list) {
                    if (BaseDomain.DEL_FLAG_DELETE.equals(t.getDelFlag())) {
                        return deleteErrorByStatus(id, null);
                    }
                    t.setDelFlag(BaseDomain.DEL_FLAG_DELETE);

                }
                result = service.updateBatchById(list);
                for (T t : list) {
                    if (ObjectUtil.isNotEmpty(consumer)) {
                        consumer.accept(t);
                    }
                }
            }
        }
        return result ? deleteSuccess(id, null) : deleteNotFound(id, null);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected <S> R<S> selectSuccess(S data, Object other) {
        return R.selectSuccess(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> insertSuccess(Object data, Object other) {
        return R.insertSuccess(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> updateSuccess(Object data, Object other) {
        return R.updateSuccess(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> updateNotFound(Object data, Object other) {
        return R.updateNotFound(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> selectNotFound(Object data, Object other) {
        return R.selectNotFound(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> deleteSuccess(Object data, Object other) {
        return R.deleteSuccess(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> deleteNotFound(Object data, Object other) {
        return R.deleteNotFound(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> deleteErrorByStatus(Object data, Object other) {
        return R.deleteErrorByStatus(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> argumentError(Object data, Object other) {
        return R.argumentError(data, other);
    }

    /**
     * 参数错误
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> operationSuccess(Object data, Object other) {
        return R.operationSuccess(data, other);
    }

    /**
     * 参数错误
     * @param message   消息
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> operationFail(String message, Object data, Object other) {
        return R.operationError(message, data, other);
    }

    /**
     * 判断集合中是否存在数据，存在则返回查询成功反之失败
     * @param list      集合
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    protected R<?> checkSuccess(List<?> list, Object data, Object other) {
        return CollectionUtil.isNotEmpty(list) ? R.selectSuccess(list, data) : R.selectNotFound(data, other);
    }

    /**
     * 判断查询后的结果是否不为空，不为空返回查询成功反之返回查询失败
     * @param list  查询后的集合
     * @param data  数据
     * @param other 其他数据
     * @return      不为空返回查询成功反之返回查询失败
     */
    protected R<?> selectResult(List<?> list, Object data, Object other) {
        return CollectionUtil.isNotEmpty(list) ? R.selectSuccess(list, data) : R.selectNotFound(data, other);
    }
}
